import re

from . import cleaners
from .symbols import symbols
import json
# # Mappings from symbol to numeric ID and vice versa:
# _symbol_to_id = {s: i for i, s in enumerate(symbols)}
# _id_to_symbol = {i: s for i, s in enumerate(symbols)}

# # Regular expression matching text enclosed in curly braces:
# _curly_re = re.compile(r'(.*?)\{(.+?)\}(.*)')


# pinyin_to_id_dict_file = 'biaobei_pinyin_to_id_dict.json'
pinyin_to_id_dict_file = 'biaobei_phone_to_id_dict.json'
pinyin_to_id_dict = {}
id_to_pinyin_dict = {}
with open(pinyin_to_id_dict_file,'r') as f:
    pinyin_to_id_dict = json.load(f)
    pinyin_to_id_dict =  {key:value+1 for key,value in pinyin_to_id_dict.items()}
    id_to_pinyin_dict = {value:key for key,value in pinyin_to_id_dict.items()}

def text_to_sequence(text, cleaner_names):

   
  text_list = text.split(' ')
  # pdb.set_trace()
  seq_list = [pinyin_to_id_dict[text] for text in text_list]
  seq_list.append(pinyin_to_id_dict['EOS'])
  return seq_list
# def text_to_sequence(text, cleaner_names):
#   '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.

#     The text can optionally have ARPAbet sequences enclosed in curly braces embedded
#     in it. For example, "Turn left on {HH AW1 S S T AH0 N} Street."

#     Args:
#       text: string to convert to a sequence
#       cleaner_names: names of the cleaner functions to run the text through

#     Returns:
#       List of integers corresponding to the symbols in the text
#   '''
#   sequence = []

#   # Check for curly braces and treat their contents as ARPAbet:
#   while len(text):
#     m = _curly_re.match(text)
#     if not m:
#       sequence += _symbols_to_sequence(_clean_text(text, cleaner_names))
#       break
#     sequence += _symbols_to_sequence(_clean_text(m.group(1), cleaner_names))
#     sequence += _arpabet_to_sequence(m.group(2))
#     text = m.group(3)

#   # Append EOS token
#   sequence.append(_symbol_to_id['~'])
#   return sequence

def sequence_to_text(sequence):
  '''Converts a sequence of IDs back to a string'''
  # print(sequence)
  text_list = [id_to_pinyin_dict[py_id] for py_id in sequence if py_id != 0 ]
  result = ' '.join(text_list)
  # pdb.set_trace()
  return result
# def sequence_to_text(sequence):
#   '''Converts a sequence of IDs back to a string'''
#   result = ''
#   for symbol_id in sequence:
#     if symbol_id in _id_to_symbol:
#       s = _id_to_symbol[symbol_id]
#       # Enclose ARPAbet back in curly braces:
#       if len(s) > 1 and s[0] == '@':
#         s = '{%s}' % s[1:]
#       result += s
#   return result.replace('}{', ' ')


def _clean_text(text, cleaner_names):
  for name in cleaner_names:
    cleaner = getattr(cleaners, name)
    if not cleaner:
      raise Exception('Unknown cleaner: %s' % name)
    text = cleaner(text)
  return text


def _symbols_to_sequence(symbols):
  return [_symbol_to_id[s] for s in symbols if _should_keep_symbol(s)]


def _arpabet_to_sequence(text):
  return _symbols_to_sequence(['@' + s for s in text.split()])


def _should_keep_symbol(s):
  return s in _symbol_to_id and s is not '_' and s is not '~'
